home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / cvs-1.8 / cvs-1 / cvs-1.8.1 / src / myndbm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-06  |  5.7 KB  |  289 lines
  1. /*
  2.  * Copyright (c) 1992, Brian Berliner
  3.  * 
  4.  * You may distribute under the terms of the GNU General Public License as
  5.  * specified in the README file that comes with the CVS 1.4 kit.
  6.  * 
  7.  * A simple ndbm-emulator for CVS.  It parses a text file of the format:
  8.  * 
  9.  * key    value
  10.  * 
  11.  * at dbm_open time, and loads the entire file into memory.  As such, it is
  12.  * probably only good for fairly small modules files.  Ours is about 30K in
  13.  * size, and this code works fine.
  14.  */
  15.  
  16. #include <assert.h>
  17. #include "cvs.h"
  18. #include "getline.h"
  19.  
  20. #ifdef MY_NDBM
  21.  
  22. static void mydbm_load_file ();
  23.  
  24. /* ARGSUSED */
  25. DBM *
  26. mydbm_open (file, flags, mode)
  27.     char *file;
  28.     int flags;
  29.     int mode;
  30. {
  31.     FILE *fp;
  32.     DBM *db;
  33.  
  34.     fp = fopen (file, FOPEN_BINARY_READ);
  35.     if (fp == NULL && !(existence_error (errno) && (flags & O_CREAT)))
  36.     return ((DBM *) 0);
  37.  
  38.     db = (DBM *) xmalloc (sizeof (*db));
  39.     db->dbm_list = getlist ();
  40.     db->modified = 0;
  41.     db->name = xstrdup (file);
  42.  
  43.     if (fp != NULL)
  44.     {
  45.     mydbm_load_file (fp, db->dbm_list);
  46.     if (fclose (fp) < 0)
  47.         error (0, errno, "cannot close %s", file);
  48.     }
  49.     return (db);
  50. }
  51.  
  52. static int write_item PROTO ((Node *, void *));
  53.  
  54. static int
  55. write_item (node, data)
  56.     Node *node;
  57.     void *data;
  58. {
  59.     FILE *fp = (FILE *)data;
  60.     fputs (node->key, fp);
  61.     fputs (" ", fp);
  62.     fputs (node->data, fp);
  63.     fputs ("\012", fp);
  64.     return 0;
  65. }
  66.  
  67. void
  68. mydbm_close (db)
  69.     DBM *db;
  70. {
  71.     if (db->modified)
  72.     {
  73.     FILE *fp;
  74.     fp = fopen (db->name, FOPEN_BINARY_WRITE);
  75.     if (fp == NULL)
  76.         error (1, errno, "cannot write %s", db->name);
  77.     walklist (db->dbm_list, write_item, (void *)fp);
  78.     if (fclose (fp) < 0)
  79.         error (0, errno, "cannot close %s", db->name);
  80.     }
  81.     free (db->name);
  82.     dellist (&db->dbm_list);
  83.     free ((char *) db);
  84. }
  85.  
  86. datum
  87. mydbm_fetch (db, key)
  88.     DBM *db;
  89.     datum key;
  90. {
  91.     Node *p;
  92.     char *s;
  93.     datum val;
  94.  
  95.     /* make sure it's null-terminated */
  96.     s = xmalloc (key.dsize + 1);
  97.     (void) strncpy (s, key.dptr, key.dsize);
  98.     s[key.dsize] = '\0';
  99.  
  100.     p = findnode (db->dbm_list, s);
  101.     if (p)
  102.     {
  103.     val.dptr = p->data;
  104.     val.dsize = strlen (p->data);
  105.     }
  106.     else
  107.     {
  108.     val.dptr = (char *) NULL;
  109.     val.dsize = 0;
  110.     }
  111.     free (s);
  112.     return (val);
  113. }
  114.  
  115. datum
  116. mydbm_firstkey (db)
  117.     DBM *db;
  118. {
  119.     Node *head, *p;
  120.     datum key;
  121.  
  122.     head = db->dbm_list->list;
  123.     p = head->next;
  124.     if (p != head)
  125.     {
  126.     key.dptr = p->key;
  127.     key.dsize = strlen (p->key);
  128.     }
  129.     else
  130.     {
  131.     key.dptr = (char *) NULL;
  132.     key.dsize = 0;
  133.     }
  134.     db->dbm_next = p->next;
  135.     return (key);
  136. }
  137.  
  138. datum
  139. mydbm_nextkey (db)
  140.     DBM *db;
  141. {
  142.     Node *head, *p;
  143.     datum key;
  144.  
  145.     head = db->dbm_list->list;
  146.     p = db->dbm_next;
  147.     if (p != head)
  148.     {
  149.     key.dptr = p->key;
  150.     key.dsize = strlen (p->key);
  151.     }
  152.     else
  153.     {
  154.     key.dptr = (char *) NULL;
  155.     key.dsize = 0;
  156.     }
  157.     db->dbm_next = p->next;
  158.     return (key);
  159. }
  160.  
  161. /* Note: only updates the in-memory copy, which is written out at
  162.    mydbm_close time.  Note: Also differs from DBM in that on duplication,
  163.    it gives a warning, rather than either DBM_INSERT or DBM_REPLACE
  164.    behavior.  */
  165. int
  166. mydbm_store (db, key, value, flags)
  167.     DBM *db;
  168.     datum key;
  169.     datum value;
  170.     int flags;
  171. {
  172.     Node *node;
  173.  
  174.     node = getnode ();
  175.     node->type = NDBMNODE;
  176.  
  177.     node->key = xmalloc (key.dsize + 1);
  178.     strncpy (node->key, key.dptr, key.dsize);
  179.     node->key[key.dsize] = '\0';
  180.  
  181.     node->data = xmalloc (value.dsize + 1);
  182.     strncpy (node->data, value.dptr, value.dsize);
  183.     node->data[value.dsize] = '\0';
  184.  
  185.     db->modified = 1;
  186.     if (addnode (db->dbm_list, node) == -1)
  187.     {
  188.     error (0, 0, "attempt to insert duplicate key `%s'", node->key);
  189.     freenode (node);
  190.     return 0;
  191.     }
  192.     return 0;
  193. }
  194.  
  195. static void
  196. mydbm_load_file (fp, list)
  197.     FILE *fp;
  198.     List *list;
  199. {
  200.     char *line = NULL;
  201.     size_t line_len;
  202.     /* FIXME: arbitrary limit.  */
  203.     char value[MAXLINELEN];
  204.     char *cp, *vp;
  205.     int len, cont;
  206.  
  207.     for (cont = 0; getline (&line, &line_len, fp) >= 0;)
  208.     {
  209.     if ((cp = strrchr (line, '\012')) != NULL)
  210.         *cp = '\0';            /* strip the newline */
  211.     cp = line + strlen (line);
  212.     if (cp > line && cp[-1] == '\015')
  213.         /* If the file (e.g. modules) was written on an NT box, it will
  214.            contain CRLF at the ends of lines.  Strip them (we can't do
  215.            this by opening the file in text mode because we might be
  216.            running on unix).  */
  217.         cp[-1] = '\0';        
  218.  
  219.     /*
  220.      * Add the line to the value, at the end if this is a continuation
  221.      * line; otherwise at the beginning, but only after any trailing
  222.      * backslash is removed.
  223.      */
  224.     vp = value;
  225.     if (cont)
  226.         vp += strlen (value);
  227.  
  228.     /*
  229.      * See if the line we read is a continuation line, and strip the
  230.      * backslash if so.
  231.      */
  232.     len = strlen (line);
  233.     if (len > 0)
  234.         cp = &line[len - 1];
  235.     else
  236.         cp = line;
  237.     if (*cp == '\\')
  238.     {
  239.         cont = 1;
  240.         *cp = '\0';
  241.     }
  242.     else
  243.     {
  244.         cont = 0;
  245.     }
  246.     (void) strcpy (vp, line);
  247.     if (value[0] == '#')
  248.         continue;            /* comment line */
  249.     vp = value;
  250.     while (*vp && isspace (*vp))
  251.         vp++;
  252.     if (*vp == '\0')
  253.         continue;            /* empty line */
  254.  
  255.     /*
  256.      * If this was not a continuation line, add the entry to the database
  257.      */
  258.     if (!cont)
  259.     {
  260.         Node *p = getnode ();
  261.         char *kp;
  262.  
  263.         kp = vp;
  264.         while (*vp && !isspace (*vp))
  265.         vp++;
  266.         *vp++ = '\0';        /* NULL terminate the key */
  267.         p->type = NDBMNODE;
  268.         p->key = xstrdup (kp);
  269.         while (*vp && isspace (*vp))
  270.         vp++;            /* skip whitespace to value */
  271.         if (*vp == '\0')
  272.         {
  273.         error (0, 0, "warning: NULL value for key `%s'", p->key);
  274.         freenode (p);
  275.         continue;
  276.         }
  277.         p->data = xstrdup (vp);
  278.         if (addnode (list, p) == -1)
  279.         {
  280.         error (0, 0, "duplicate key found for `%s'", p->key);
  281.         freenode (p);
  282.         }
  283.     }
  284.     }
  285.     free (line);
  286. }
  287.  
  288. #endif                /* MY_NDBM */
  289.